/*
 A JavaScript implementation of the SHA family of hashes, as
 defined in FIPS PUB 180-4 and FIPS PUB 202, as well as the corresponding
 HMAC implementation as defined in FIPS PUB 198a

 Copyright Brian Turek 2008-2017
 Distributed under the BSD License
 See http://caligatio.github.com/jsSHA/ for more information

 Several functions taken from Paul Johnston
*/
'use strict';
(function (Y) {
  function C(c, a, b) {
    var e = 0, h = [], n = 0, g, l, d, f, m, q, u, r, I = !1, v = [], w = [], t,
        y = !1, z = !1, x = -1;
    b = b || {};
    g = b.encoding || "UTF8";
    t = b.numRounds || 1;
    if (t !== parseInt(t, 10) || 1 > t) {
      throw Error(
          "numRounds must a integer >= 1");
    }
    if ("SHA-1" === c) {
      m = 512, q = K, u = Z, f = 160, r = function (a) {
        return a.slice()
      };
    } else if (0 === c.lastIndexOf("SHA-", 0)) {
      if (q = function (a, b) {
            return L(a, b, c)
          }, u = function (a, b, h, e) {
            var k, f;
            if ("SHA-224" === c || "SHA-256" === c) {
              k = (b + 65 >>> 9 << 4)
                  + 15, f = 16;
            } else if ("SHA-384" === c || "SHA-512" === c) {
              k = (b
                  + 129 >>> 10 <<
                  5) + 31, f = 32;
            } else {
              throw Error(
                  "Unexpected error in SHA-2 implementation");
            }
            for (; a.length <= k;) {
              a.push(0);
            }
            a[b >>> 5] |= 128 << 24 - b % 32;
            b = b + h;
            a[k] = b & 4294967295;
            a[k - 1] = b / 4294967296 | 0;
            h = a.length;
            for (b = 0; b < h; b += f) {
              e = L(a.slice(b, b + f), e, c);
            }
            if ("SHA-224" === c) {
              a = [e[0], e[1], e[2], e[3], e[4], e[5],
                e[6]];
            } else if ("SHA-256" === c) {
              a = e;
            } else if ("SHA-384"
                === c) {
              a = [e[0].a, e[0].b, e[1].a, e[1].b, e[2].a, e[2].b,
                e[3].a, e[3].b, e[4].a, e[4].b, e[5].a, e[5].b];
            } else if ("SHA-512"
                === c) {
              a = [e[0].a, e[0].b, e[1].a, e[1].b, e[2].a, e[2].b,
                e[3].a, e[3].b, e[4].a,
                e[4].b, e[5].a, e[5].b, e[6].a, e[6].b, e[7].a,
                e[7].b];
            } else {
              throw Error(
                  "Unexpected error in SHA-2 implementation");
            }
            return a
          }, r = function (a) {
            return a.slice()
          }, "SHA-224" === c) {
        m = 512, f = 224;
      } else if ("SHA-256"
          === c) {
        m = 512, f = 256;
      } else if ("SHA-384"
          === c) {
        m = 1024, f = 384;
      } else if ("SHA-512"
          === c) {
        m = 1024, f = 512;
      } else {
        throw Error(
            "Chosen SHA variant is not supported");
      }
    } else if (0 === c.lastIndexOf(
            "SHA3-", 0) || 0 === c.lastIndexOf("SHAKE", 0)) {
      var F = 6;
      q = D;
      r = function (a) {
        var c = [], e;
        for (e = 0; 5 > e; e += 1) {
          c[e] = a[e].slice();
        }
        return c
      };
      x = 1;
      if ("SHA3-224" ===
          c) {
        m = 1152, f = 224;
      } else if ("SHA3-256"
          === c) {
        m = 1088, f = 256;
      } else if ("SHA3-384"
          === c) {
        m = 832, f = 384;
      } else if ("SHA3-512"
          === c) {
        m = 576, f = 512;
      } else if ("SHAKE128"
          === c) {
        m = 1344, f = -1, F = 31, z = !0;
      } else if ("SHAKE256"
          === c) {
        m = 1088, f = -1, F = 31, z = !0;
      } else {
        throw Error(
            "Chosen SHA variant is not supported");
      }
      u = function (a, c, e, b, h) {
        e = m;
        var k = F, f, g = [], n = e >>> 5, l = 0, d = c >>> 5;
        for (f = 0; f < d && c >= e; f += n) {
          b = D(a.slice(f, f + n),
              b), c -= e;
        }
        a = a.slice(f);
        for (c %= e; a.length < n;) {
          a.push(0);
        }
        f = c >>> 3;
        a[f >> 2] ^= k << f % 4 * 8;
        a[n - 1] ^= 2147483648;
        for (b = D(a, b); 32 * g.length < h;) {
          a = b[l %
          5][l / 5 | 0];
          g.push(a.b);
          if (32 * g.length >= h) {
            break;
          }
          g.push(a.a);
          l += 1;
          0 === 64 * l % e && D(null, b)
        }
        return g
      }
    } else {
      throw Error("Chosen SHA variant is not supported");
    }
    d = M(a, g, x);
    l = A(c);
    this.setHMACKey = function (a, b, h) {
      var k;
      if (!0 === I) {
        throw Error("HMAC key already set");
      }
      if (!0 === y) {
        throw Error("Cannot set HMAC key after calling update");
      }
      if (!0 === z) {
        throw Error("SHAKE is not supported for HMAC");
      }
      g = (h || {}).encoding || "UTF8";
      b = M(b, g, x)(a);
      a = b.binLen;
      b = b.value;
      k = m >>> 3;
      h = k / 4 - 1;
      if (k < a / 8) {
        for (b = u(b, a, 0, A(c), f); b.length <= h;) {
          b.push(0);
        }
        b[h] &= 4294967040
      } else if (k > a / 8) {
        for (; b.length <= h;) {
          b.push(0);
        }
        b[h] &= 4294967040
      }
      for (a = 0; a <= h; a += 1) {
        v[a] = b[a] ^ 909522486, w[a] = b[a]
            ^ 1549556828;
      }
      l = q(v, l);
      e = m;
      I = !0
    };
    this.update = function (a) {
      var c, b, k, f = 0, g = m >>> 5;
      c = d(a, h, n);
      a = c.binLen;
      b = c.value;
      c = a >>> 5;
      for (k = 0; k < c; k += g) {
        f + m <= a && (l = q(b.slice(k, k + g),
            l), f += m);
      }
      e += f;
      h = b.slice(f >>> 5);
      n = a % m;
      y = !0
    };
    this.getHash = function (a, b) {
      var k, g, d, m;
      if (!0 === I) {
        throw Error("Cannot call getHash after setting HMAC key");
      }
      d = N(b);
      if (!0 === z) {
        if (-1 === d.shakeLen) {
          throw Error(
              "shakeLen must be specified in options");
        }
        f = d.shakeLen
      }
      switch (a) {
        case "HEX":
          k = function (a) {
            return O(a, f, x, d)
          };
          break;
        case "B64":
          k = function (a) {
            return P(a, f, x, d)
          };
          break;
        case "BYTES":
          k = function (a) {
            return Q(a, f, x)
          };
          break;
        case "ARRAYBUFFER":
          try {
            g = new ArrayBuffer(0)
          } catch (p) {
            throw Error("ARRAYBUFFER not supported by this environment");
          }
          k = function (a) {
            return R(a, f, x)
          };
          break;
        default:
          throw Error("format must be HEX, B64, BYTES, or ARRAYBUFFER");
      }
      m = u(h.slice(), n, e, r(l), f);
      for (g = 1; g < t; g += 1) {
        !0 === z && 0 !== f % 32 && (m[m.length
        - 1] &= 16777215 >>> 24 - f % 32), m = u(m, f,
            0, A(c), f);
      }
      return k(m)
    };
    this.getHMAC = function (a, b) {
      var k, g, d, p;
      if (!1 === I) {
        throw Error(
            "Cannot call getHMAC without first setting HMAC key");
      }
      d = N(b);
      switch (a) {
        case "HEX":
          k = function (a) {
            return O(a, f, x, d)
          };
          break;
        case "B64":
          k = function (a) {
            return P(a, f, x, d)
          };
          break;
        case "BYTES":
          k = function (a) {
            return Q(a, f, x)
          };
          break;
        case "ARRAYBUFFER":
          try {
            k = new ArrayBuffer(0)
          } catch (v) {
            throw Error("ARRAYBUFFER not supported by this environment");
          }
          k = function (a) {
            return R(a, f, x)
          };
          break;
        default:
          throw Error("outputFormat must be HEX, B64, BYTES, or ARRAYBUFFER");
      }
      g = u(h.slice(), n, e, r(l), f);
      p = q(w, A(c));
      p = u(g, f, m, p, f);
      return k(p)
    }
  }

  function b(c, a) {
    this.a = c;
    this.b = a
  }

  function O(c, a, b, e) {
    var h = "";
    a /= 8;
    var n, g, d;
    d = -1 === b ? 3 : 0;
    for (n = 0; n < a; n += 1) {
      g = c[n >>> 2] >>> 8 * (d + n % 4
          * b), h += "0123456789abcdef".charAt(g >>> 4 & 15)
          + "0123456789abcdef".charAt(g & 15);
    }
    return e.outputUpper ? h.toUpperCase() : h
  }

  function P(c, a, b, e) {
    var h = "", n = a / 8, g, d, p, f;
    f = -1 === b ? 3 : 0;
    for (g = 0; g < n; g += 3) {
      for (d = g + 1 < n ? c[g + 1 >>> 2] : 0, p = g
      + 2 < n ? c[g + 2 >>> 2] : 0, p = (c[g >>> 2] >>> 8 * (f + g % 4 * b)
          & 255)
          << 16 | (d >>> 8 * (f + (g + 1) % 4 * b) & 255) << 8 | p >>> 8 * (f +
              (g + 2) % 4 * b) & 255, d = 0; 4 > d; d += 1) {
        8 * g + 6 * d <= a
            ? h += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(p
            >>> 6 * (3 - d) & 63) : h += e.b64Pad;
      }
    }
    return h
  }

  function Q(c, a, b) {
    var e = "";
    a /= 8;
    var h, d, g;
    g = -1 === b ? 3 : 0;
    for (h = 0; h < a; h += 1) {
      d = c[h >>> 2] >>> 8 * (g + h % 4 * b)
          & 255, e += String.fromCharCode(d);
    }
    return e
  }

  function R(c, a, b) {
    a /= 8;
    var e, h = new ArrayBuffer(a), d, g;
    g = new Uint8Array(h);
    d = -1 === b ? 3 : 0;
    for (e = 0; e < a; e += 1) {
      g[e] = c[e >>> 2] >>> 8 * (d + e % 4 * b) & 255;
    }
    return h
  }

  function N(c) {
    var a = {outputUpper: !1, b64Pad: "=", shakeLen: -1};
    c = c || {};
    a.outputUpper = c.outputUpper || !1;
    !0 === c.hasOwnProperty("b64Pad") && (a.b64Pad = c.b64Pad);
    if (!0 === c.hasOwnProperty("shakeLen")) {
      if (0 !== c.shakeLen % 8) {
        throw Error("shakeLen must be a multiple of 8");
      }
      a.shakeLen = c.shakeLen
    }
    if ("boolean" !== typeof a.outputUpper) {
      throw Error(
          "Invalid outputUpper formatting option");
    }
    if ("string" !== typeof a.b64Pad) {
      throw Error(
          "Invalid b64Pad formatting option");
    }
    return a
  }

  function M(c, a, b) {
    switch (a) {
      case "UTF8":
      case "UTF16BE":
      case "UTF16LE":
        break;
      default:
        throw Error("encoding must be UTF8, UTF16BE, or UTF16LE");
    }
    switch (c) {
      case "HEX":
        c = function (a, c, d) {
          var g = a.length, l, p, f, m, q, u;
          if (0 !== g % 2) {
            throw Error(
                "String of HEX type must be in byte increments");
          }
          c = c || [0];
          d = d || 0;
          q = d >>> 3;
          u = -1 === b ? 3 : 0;
          for (l = 0; l < g; l += 2) {
            p = parseInt(a.substr(l, 2), 16);
            if (isNaN(p)) {
              throw Error(
                  "String of HEX type contains invalid characters");
            }
            m = (l >>> 1) + q;
            for (f = m >>> 2; c.length <= f;) {
              c.push(0);
            }
            c[f] |= p << 8 * (u + m % 4 * b)
          }
          return {value: c, binLen: 4 * g + d}
        };
        break;
      case "TEXT":
        c = function (c, h, d) {
          var g, l, p = 0, f, m, q, u, r, t;
          h = h || [0];
          d = d || 0;
          q = d >>> 3;
          if ("UTF8" === a) {
            for (t = -1 ===
            b ? 3 : 0, f = 0; f < c.length; f += 1) {
              for (g = c.charCodeAt(
                  f), l = [], 128 > g ? l.push(g) : 2048 > g ? (l.push(192 | g
                  >>> 6), l.push(128 | g & 63)) : 55296 > g || 57344 <= g
                  ? l.push(224 | g >>> 12, 128 | g >>> 6 & 63, 128 | g & 63)
                  : (f += 1, g = 65536 + ((g & 1023) << 10 | c.charCodeAt(f)
                      & 1023), l.push(240 | g >>> 18, 128 | g >>> 12 & 63, 128
                      | g
                      >>> 6 & 63, 128 | g & 63)), m = 0; m < l.length; m += 1) {
                r = p + q;
                for (u = r >>> 2; h.length <= u;) {
                  h.push(0);
                }
                h[u] |= l[m] << 8 * (t + r % 4 * b);
                p += 1
              }
            }
          } else if ("UTF16BE" === a || "UTF16LE" === a) {
            for (t = -1 === b ? 2
                : 0, l = "UTF16LE" === a && 1 !== b || "UTF16LE" !== a && 1
                === b, f = 0; f < c.length; f += 1) {
              g = c.charCodeAt(f);
              !0 === l && (m = g & 255, g = m << 8 | g >>> 8);
              r = p + q;
              for (u = r >>> 2; h.length <= u;) {
                h.push(0);
              }
              h[u] |= g << 8 * (t + r % 4 * b);
              p += 2
            }
          }
          return {value: h, binLen: 8 * p + d}
        };
        break;
      case "B64":
        c = function (a, c, d) {
          var g = 0, l, p, f, m, q, u, r, t;
          if (-1 === a.search(/^[a-zA-Z0-9=+\/]+$/)) {
            throw Error(
                "Invalid character in base-64 string");
          }
          p = a.indexOf("=");
          a = a.replace(/\=/g, "");
          if (-1 !== p && p < a.length) {
            throw Error(
                "Invalid '=' found in base-64 string");
          }
          c = c || [0];
          d = d || 0;
          u = d >>> 3;
          t = -1 === b ? 3 : 0;
          for (p = 0; p < a.length; p += 4) {
            q = a.substr(p, 4);
            for (f = m = 0; f < q.length;
                f += 1) {
              l = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(
                  q[f]),
                  m |= l << 18 - 6 * f;
            }
            for (f = 0; f < q.length - 1; f += 1) {
              r = g + u;
              for (l = r >>> 2; c.length <= l;) {
                c.push(0);
              }
              c[l] |= (m >>> 16 - 8 * f & 255) << 8 * (t + r % 4 * b);
              g += 1
            }
          }
          return {value: c, binLen: 8 * g + d}
        };
        break;
      case "BYTES":
        c = function (a, c, d) {
          var g, l, p, f, m, q;
          c = c || [0];
          d = d || 0;
          p = d >>> 3;
          q = -1 === b ? 3 : 0;
          for (l = 0; l < a.length; l += 1) {
            g = a.charCodeAt(l), m = l
                + p, f = m >>> 2, c.length <= f && c.push(0), c[f] |= g << 8
                * (q
                    + m % 4 * b);
          }
          return {value: c, binLen: 8 * a.length + d}
        };
        break;
      case "ARRAYBUFFER":
        try {
          c = new ArrayBuffer(0)
        } catch (e) {
          throw Error("ARRAYBUFFER not supported by this environment");
        }
        c =
            function (a, c, d) {
              var g, l, p, f, m, q;
              c = c || [0];
              d = d || 0;
              l = d >>> 3;
              m = -1 === b ? 3 : 0;
              q = new Uint8Array(a);
              for (g = 0; g < a.byteLength; g += 1) {
                f = g + l, p = f
                    >>> 2, c.length <= p && c.push(0), c[p] |= q[g] << 8 * (m
                    + f
                    % 4 * b);
              }
              return {value: c, binLen: 8 * a.byteLength + d}
            };
        break;
      default:
        throw Error("format must be HEX, TEXT, B64, BYTES, or ARRAYBUFFER");
    }
    return c
  }

  function y(c, a) {
    return c << a | c >>> 32 - a
  }

  function S(c, a) {
    return 32 < a ? (a -= 32, new b(c.b << a | c.a >>> 32 - a, c.a << a | c.b
        >>> 32 - a)) : 0 !== a ? new b(c.a << a | c.b >>> 32 - a, c.b << a | c.a
        >>> 32 - a) : c
  }

  function w(c, a) {
    return c >>>
        a | c << 32 - a
  }

  function t(c, a) {
    var k = null, k = new b(c.a, c.b);
    return k = 32 >= a ? new b(k.a >>> a | k.b << 32 - a & 4294967295, k.b >>> a
        | k.a << 32 - a & 4294967295) : new b(k.b >>> a - 32 | k.a << 64 - a
        & 4294967295, k.a >>> a - 32 | k.b << 64 - a & 4294967295)
  }

  function T(c, a) {
    var k = null;
    return k = 32 >= a ? new b(c.a >>> a, c.b >>> a | c.a << 32 - a
        & 4294967295) : new b(0, c.a >>> a - 32)
  }

  function aa(c, a, b) {
    return c & a ^ ~c & b
  }

  function ba(c, a, k) {
    return new b(c.a & a.a ^ ~c.a & k.a, c.b & a.b ^ ~c.b & k.b)
  }

  function U(c, a, b) {
    return c & a ^ c & b ^ a & b
  }

  function ca(c, a, k) {
    return new b(c.a & a.a ^ c.a & k.a ^ a.a &
        k.a, c.b & a.b ^ c.b & k.b ^ a.b & k.b)
  }

  function da(c) {
    return w(c, 2) ^ w(c, 13) ^ w(c, 22)
  }

  function ea(c) {
    var a = t(c, 28), k = t(c, 34);
    c = t(c, 39);
    return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
  }

  function fa(c) {
    return w(c, 6) ^ w(c, 11) ^ w(c, 25)
  }

  function ga(c) {
    var a = t(c, 14), k = t(c, 18);
    c = t(c, 41);
    return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
  }

  function ha(c) {
    return w(c, 7) ^ w(c, 18) ^ c >>> 3
  }

  function ia(c) {
    var a = t(c, 1), k = t(c, 8);
    c = T(c, 7);
    return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
  }

  function ja(c) {
    return w(c, 17) ^ w(c, 19) ^ c >>> 10
  }

  function ka(c) {
    var a = t(c, 19), k = t(c, 61);
    c = T(c, 6);
    return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
  }

  function G(c, a) {
    var b = (c & 65535) + (a & 65535);
    return ((c >>> 16) + (a >>> 16) + (b >>> 16) & 65535) << 16 | b & 65535
  }

  function la(c, a, b, e) {
    var h = (c & 65535) + (a & 65535) + (b & 65535) + (e & 65535);
    return ((c >>> 16) + (a >>> 16) + (b >>> 16) + (e >>> 16) + (h >>> 16)
        & 65535) << 16 | h & 65535
  }

  function H(c, a, b, e, h) {
    var d = (c & 65535) + (a & 65535) + (b & 65535) + (e & 65535) + (h & 65535);
    return ((c >>> 16) + (a >>> 16) + (b >>> 16) + (e >>> 16) + (h >>> 16) + (d
        >>> 16) & 65535) << 16 | d & 65535
  }

  function ma(c, a) {
    var d, e, h;
    d = (c.b & 65535) + (a.b & 65535);
    e = (c.b >>> 16) +
        (a.b >>> 16) + (d >>> 16);
    h = (e & 65535) << 16 | d & 65535;
    d = (c.a & 65535) + (a.a & 65535) + (e >>> 16);
    e = (c.a >>> 16) + (a.a >>> 16) + (d >>> 16);
    return new b((e & 65535) << 16 | d & 65535, h)
  }

  function na(c, a, d, e) {
    var h, n, g;
    h = (c.b & 65535) + (a.b & 65535) + (d.b & 65535) + (e.b & 65535);
    n = (c.b >>> 16) + (a.b >>> 16) + (d.b >>> 16) + (e.b >>> 16) + (h >>> 16);
    g = (n & 65535) << 16 | h & 65535;
    h = (c.a & 65535) + (a.a & 65535) + (d.a & 65535) + (e.a & 65535) + (n
        >>> 16);
    n = (c.a >>> 16) + (a.a >>> 16) + (d.a >>> 16) + (e.a >>> 16) + (h >>> 16);
    return new b((n & 65535) << 16 | h & 65535, g)
  }

  function oa(c, a, d, e, h) {
    var n, g, l;
    n = (c.b &
        65535) + (a.b & 65535) + (d.b & 65535) + (e.b & 65535) + (h.b & 65535);
    g = (c.b >>> 16) + (a.b >>> 16) + (d.b >>> 16) + (e.b >>> 16) + (h.b >>> 16)
        + (n >>> 16);
    l = (g & 65535) << 16 | n & 65535;
    n = (c.a & 65535) + (a.a & 65535) + (d.a & 65535) + (e.a & 65535) + (h.a
        & 65535) + (g >>> 16);
    g = (c.a >>> 16) + (a.a >>> 16) + (d.a >>> 16) + (e.a >>> 16) + (h.a >>> 16)
        + (n >>> 16);
    return new b((g & 65535) << 16 | n & 65535, l)
  }

  function B(c, a) {
    return new b(c.a ^ a.a, c.b ^ a.b)
  }

  function A(c) {
    var a = [], d;
    if ("SHA-1" === c) {
      a = [1732584193, 4023233417, 2562383102, 271733878,
        3285377520];
    } else if (0 === c.lastIndexOf("SHA-", 0)) {
      switch (a =
          [3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025,
            1694076839, 3204075428], d = [1779033703, 3144134277, 1013904242,
        2773480762, 1359893119, 2600822924, 528734635, 1541459225], c) {
        case "SHA-224":
          break;
        case "SHA-256":
          a = d;
          break;
        case "SHA-384":
          a = [new b(3418070365, a[0]), new b(1654270250, a[1]),
            new b(2438529370, a[2]), new b(355462360, a[3]),
            new b(1731405415, a[4]), new b(41048885895, a[5]),
            new b(3675008525, a[6]), new b(1203062813, a[7])];
          break;
        case "SHA-512":
          a = [new b(d[0], 4089235720), new b(d[1], 2227873595),
            new b(d[2], 4271175723), new b(d[3], 1595750129),
            new b(d[4], 2917565137), new b(d[5], 725511199),
            new b(d[6], 4215389547), new b(d[7], 327033209)];
          break;
        default:
          throw Error("Unknown SHA variant");
      }
    } else if (0 === c.lastIndexOf("SHA3-", 0) || 0 === c.lastIndexOf("SHAKE",
            0)) {
      for (c = 0; 5 > c; c += 1) {
        a[c] = [new b(0, 0), new b(0, 0),
          new b(0, 0), new b(0, 0), new b(0, 0)];
      }
    } else {
      throw Error(
          "No SHA variants supported");
    }
    return a
  }

  function K(c, a) {
    var b = [], e, d, n, g, l, p, f;
    e = a[0];
    d = a[1];
    n = a[2];
    g = a[3];
    l = a[4];
    for (f = 0; 80 > f; f += 1) {
      b[f] = 16 > f ? c[f] : y(b[f -
      3] ^ b[f - 8] ^ b[f - 14] ^ b[f - 16], 1), p = 20 > f ? H(y(e, 5), d & n
          ^ ~d & g, l, 1518500249, b[f]) : 40 > f ? H(y(e, 5), d ^ n ^ g, l,
          1859775393, b[f]) : 60 > f ? H(y(e, 5), U(d, n, g), l, 2400959708,
          b[f])
          : H(y(e, 5), d ^ n ^ g, l, 3395469782, b[f]), l = g, g = n, n = y(d,
          30), d = e, e = p;
    }
    a[0] = G(e, a[0]);
    a[1] = G(d, a[1]);
    a[2] = G(n, a[2]);
    a[3] = G(g, a[3]);
    a[4] = G(l, a[4]);
    return a
  }

  function Z(c, a, b, e) {
    var d;
    for (d = (a + 65 >>> 9 << 4) + 15; c.length <= d;) {
      c.push(0);
    }
    c[a >>> 5] |= 128 << 24 - a % 32;
    a += b;
    c[d] = a & 4294967295;
    c[d - 1] = a / 4294967296 | 0;
    a = c.length;
    for (d = 0; d < a; d += 16) {
      e = K(c.slice(d, d + 16), e);
    }
    return e
  }

  function L(c,
      a, k) {
    var e, h, n, g, l, p, f, m, q, u, r, t, v, w, y, A, z, x, F, B, C, D,
        E = [], J;
    if ("SHA-224" === k || "SHA-256"
        === k) {
      u = 64, t = 1, D = Number, v = G, w = la, y = H, A = ha, z = ja, x = da, F = fa, C = U, B = aa, J = d;
    } else if ("SHA-384"
        === k || "SHA-512"
        === k) {
      u = 80, t = 2, D = b, v = ma, w = na, y = oa, A = ia, z = ka, x = ea, F = ga, C = ca, B = ba, J = V;
    } else {
      throw Error(
          "Unexpected error in SHA-2 implementation");
    }
    k = a[0];
    e = a[1];
    h = a[2];
    n = a[3];
    g = a[4];
    l = a[5];
    p = a[6];
    f = a[7];
    for (r = 0; r < u; r += 1) {
      16 > r ? (q = r * t, m = c.length <= q ? 0
          : c[q], q = c.length <= q + 1 ? 0 : c[q + 1], E[r] = new D(m, q))
          : E[r] = w(z(E[r - 2]), E[r - 7], A(E[r - 15]), E[r -
          16]), m = y(f, F(g), B(g, l, p), J[r], E[r]), q = v(x(k),
          C(k, e, h)), f = p, p = l, l = g, g = v(n,
          m), n = h, h = e, e = k, k = v(m, q);
    }
    a[0] = v(k, a[0]);
    a[1] = v(e, a[1]);
    a[2] = v(h, a[2]);
    a[3] = v(n, a[3]);
    a[4] = v(g, a[4]);
    a[5] = v(l, a[5]);
    a[6] = v(p, a[6]);
    a[7] = v(f, a[7]);
    return a
  }

  function D(c, a) {
    var d, e, h, n, g = [], l = [];
    if (null !== c) {
      for (e = 0; e < c.length; e += 2) {
        a[(e >>> 1) % 5][(e >>> 1)
        / 5 | 0] = B(a[(e >>> 1) % 5][(e >>> 1) / 5 | 0],
            new b(c[e + 1], c[e]));
      }
    }
    for (d = 0; 24 > d; d += 1) {
      n = A("SHA3-");
      for (e = 0; 5 > e; e += 1) {
        h = a[e][0];
        var p = a[e][1], f = a[e][2], m = a[e][3], q = a[e][4];
        g[e] = new b(h.a ^ p.a ^ f.a ^
            m.a ^ q.a, h.b ^ p.b ^ f.b ^ m.b ^ q.b)
      }
      for (e = 0; 5 > e; e += 1) {
        l[e] = B(g[(e + 4) % 5], S(g[(e + 1) % 5], 1));
      }
      for (e = 0; 5 > e; e += 1) {
        for (h = 0; 5 > h; h += 1) {
          a[e][h] = B(a[e][h],
              l[e]);
        }
      }
      for (e = 0; 5 > e; e += 1) {
        for (h = 0; 5 > h; h += 1) {
          n[h][(2 * e + 3 * h)
          % 5] = S(a[e][h], W[e][h]);
        }
      }
      for (e = 0; 5 > e; e += 1) {
        for (h = 0; 5 > h; h += 1) {
          a[e][h] = B(n[e][h],
              new b(~n[(e + 1) % 5][h].a & n[(e + 2) % 5][h].a, ~n[(e + 1)
                  % 5][h].b
                  & n[(e + 2) % 5][h].b));
        }
      }
      a[0][0] = B(a[0][0], X[d])
    }
    return a
  }

  var d, V, W, X;
  d = [1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
    2453635748, 2870763221, 3624381080, 310598401, 607225278,
    1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401,
    4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692,
    1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891,
    3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372,
    1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921,
    2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909,
    275423344, 430227734, 506948616, 659060556, 883997877, 958139571,
    1322822218, 1537002063, 1747873779, 1955562222, 2024104815,
    2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298];
  V = [new b(d[0], 3609767458), new b(d[1], 602891725), new b(d[2], 3964484399),
    new b(d[3], 2173295548), new b(d[4], 4081628472), new b(d[5], 3053834265),
    new b(d[6], 2937671579), new b(d[7], 3664609560), new b(d[8], 2734883394),
    new b(d[9], 1164996542), new b(d[10], 1323610764), new b(d[11], 3590304994),
    new b(d[12], 4068182383), new b(d[13], 991336113), new b(d[14], 633803317),
    new b(d[15], 3479774868), new b(d[16], 2666613458), new b(d[17], 944711139),
    new b(d[18], 2341262773),
    new b(d[19], 2007800933), new b(d[20], 1495990901),
    new b(d[21], 1856431235), new b(d[22], 3175218132),
    new b(d[23], 2198950837), new b(d[24], 3999719339), new b(d[25], 766784016),
    new b(d[26], 2566594879), new b(d[27], 3203337956),
    new b(d[28], 1034457026), new b(d[29], 2466948901),
    new b(d[30], 3758326383), new b(d[31], 168717936), new b(d[32], 1188179964),
    new b(d[33], 1546045734), new b(d[34], 1522805485),
    new b(d[35], 2643833823), new b(d[36], 2343527390),
    new b(d[37], 1014477480), new b(d[38], 1206759142), new b(d[39], 344077627),
    new b(d[40], 1290863460), new b(d[41], 3158454273),
    new b(d[42], 3505952657), new b(d[43], 106217008), new b(d[44], 3606008344),
    new b(d[45], 1432725776), new b(d[46], 1467031594), new b(d[47], 851169720),
    new b(d[48], 3100823752), new b(d[49], 1363258195),
    new b(d[50], 3750685593), new b(d[51], 3785050280),
    new b(d[52], 3318307427), new b(d[53], 3812723403),
    new b(d[54], 2003034995), new b(d[55], 3602036899),
    new b(d[56], 1575990012), new b(d[57], 1125592928),
    new b(d[58], 2716904306), new b(d[59], 442776044), new b(d[60], 593698344),
    new b(d[61],
        3733110249), new b(d[62], 2999351573), new b(d[63], 3815920427),
    new b(3391569614, 3928383900), new b(3515267271, 566280711),
    new b(3940187606, 3454069534), new b(4118630271, 4000239992),
    new b(116418474, 1914138554), new b(174292421, 2731055270),
    new b(289380356, 3203993006), new b(460393269, 320620315),
    new b(685471733, 587496836), new b(852142971, 1086792851),
    new b(1017036298, 365543100), new b(1126000580, 2618297676),
    new b(1288033470, 3409855158), new b(1501505948, 4234509866),
    new b(1607167915, 987167468), new b(1816402316,
        1246189591)];
  X = [new b(0, 1), new b(0, 32898), new b(2147483648, 32906),
    new b(2147483648, 2147516416), new b(0, 32907), new b(0, 2147483649),
    new b(2147483648, 2147516545), new b(2147483648, 32777), new b(0, 138),
    new b(0, 136), new b(0, 2147516425), new b(0, 2147483658),
    new b(0, 2147516555), new b(2147483648, 139), new b(2147483648, 32905),
    new b(2147483648, 32771), new b(2147483648, 32770), new b(2147483648, 128),
    new b(0, 32778), new b(2147483648, 2147483658),
    new b(2147483648, 2147516545), new b(2147483648, 32896),
    new b(0, 2147483649),
    new b(2147483648, 2147516424)];
  W = [[0, 36, 3, 41, 18], [1, 44, 10, 45, 2], [62, 6, 43, 15, 61],
    [28, 55, 25, 21, 56], [27, 20, 39, 8, 14]];
  "function" === typeof define && define.amd ? define(function () {
    return C
  }) : "undefined" !== typeof exports ? ("undefined" !== typeof module
  && module.exports && (module.exports = C), exports = C) : Y.jsSHA = C
})(this);
